\newcommand{\err}{\upvarepsilon} 

\begin{section}{Desarrollo}
 
\begin{subsection}{Análisis Teórico}

\paragraph{}
\textbf{Serie de Gregory}
\begin{equation*}
\frac{\pi}{4} = \sum_{i=0}^{\infty} \frac{\left(-1\right)^i}{2i+1} \hspace*{50pt}
G(n) = \sum_{i=0}^{n} g_i \hspace*{10pt} \mbox{donde} \hspace*{10pt}
g_i =
\begin{cases}
\frac{-1}{2i+1} & \mbox{si i es impar} \\
\frac{1}{2i+1} & \mbox{si i es par}
\end{cases}
\end{equation*}

\textbf{Fórmula de Machin}
\begin{equation*}
\frac{\pi}{4} = 4 \; \mathrm{arctan}(1/5) - \mathrm{arctan}(1/239), \qquad \text{con } \mathrm{arctan}(x) = \sum_{i=0}^{\infty} \left(-1\right)^n \frac{x^{2i+1}}{2i+1} \quad \text{cuando } \left|x\right|<1
\end{equation*}
\begin{equation*}
M(x, n) = \sum_{i=0}^{n} {m(x)}_i \hspace*{10pt} \mbox{donde} \hspace*{10pt}
%~ \text{cuando } \left|x\right|<1
{m(x)}_i =
\begin{cases}
\frac{-x^{2i+1}}{2i+1} & \mbox{si i es impar} \\
& \\
\frac{x^{2i+1}}{2i+1} & \mbox{si i es par}
\end{cases}
\end{equation*}
    
\textbf{Serie de Ramanujan}
\begin{equation*}
\frac{1}{\pi} = \frac{\sqrt{8}}{9801} \sum_{i=0}^{\infty} \frac{(4i)! \, (1103 + 26390 i)}{(i!)^4 \, 396^{4i}} \hspace*{50pt}
R(n) = \sum_{i=0}^{n} \frac{(4i)! \, (1103 + 26390 i)}{(i!)^4 \, 396^{4i}} = \sum_{i=0}^{n} r_i
\end{equation*}

\par
El termino $(-1)^i$ toma los valores $1$ y $-1$ según la paridad de $i$. En general, este término sirve para indicar si el término $i$ de la sumatoria se suma o se resta al resultado final. Por lo tanto, $(-1)^i$ termina siendo simplemente una operación de suma o de resta. 
Por ello para el cálculo del error de un término general, se considerará como positivo dicho término y al final, se tendrá en cuenta el signo corespondiente al realizar las sumas entre todos los términos. 

%~ \paragraph{}
\begin{center} \textbf{Errores Comunes} \end{center}
$$\err_{(a+b)} = \frac{a.\err_a}{a+b} + \frac{b.\err_b}{a+b} + \err_{+}$$ 
$$\err_{(a-b)} = \frac{a.\err_a}{a-b} - \frac{b.\err_b}{a-b} + \err_{-}$$ 
$$\err_{(a*b)} = \err_a + \err_b + \err_{*}$$ 
$$\err_{(a/b)} = \err_a - \err_b + \err_{/}$$
$$\err_{(a^b)} = b.\err_a + ln(a).b.\err_b + \err_{\wedge}$$
$$\err_{(n.i)} = \err_n + \err_i + \err_{*}$$
$$\err_{(2i+1)} = \frac{2i.\err_{2i}}{2i+1} + \frac{1.\err_1}{2i+1} + \err_{+} = \frac{2i.\frac{(\err_2 + \err_i + \err_{*})}{2i}}{2i+1} + \frac{\err_1}{2i+1} + \err_{+} = \frac{(\err_2 + \err_i + \err_{*})}{2i+1} + \frac{\err_1}{2i+1} + \err_{+}$$
$$\err_{(a!)} = \err_{a*(a-1)*...*2} = \err_{a} + \err_{(a-1)*...*2} + \err{*} = ... = \err_{a} + \err_{a-1} + ... + \err_{2} + \err_{*} + \err_{*} + ... + \err_{*} = $$ 
$$\left( \sum_{i=2}^{a-2} (\err_{i} + \err_{*}) \right) + \err_{a-1} + \err_{a} = \sum_{i=2}^{a-2} (\err_{*}) + \sum_{i=2}^{a} (\err_{i}) 
\leq \sum_{i=2}^{a-2} max_{i \in \{2,...,a-2\}}(\err_{*}) + \sum_{i=2}^{a} max_{i \in \{2,...,a\}}(\err_{i}) = $$
$$ (a-4)  max_{i \in \{2,...,a-2\}}\{\err_{*}\} + (a-2) max_{i \in \{2,...,a\}}\{\err_{i}\} \leq (a-2) (max_{i \in \{2,...,a-2\}}\{\err_{*}\} + max_{i \in \{2,...,a\}}\{\err_{i}\} )$$
Para simplificar la notación este error puede verse como 
$$\err_{(a!)} \leq (a-2) (max\{\err_{*}\} + max\{\err_{i}\})$$

\paragraph{}
Como se comentó en la sección teórica, es importante destacar que los números enteros pueden ser representados sin error en una aritmética finita siempre y cuando estos se mantengan dentro del rango de la representación. Tampoco poseen error las operaciones de suma, resta y multiplicación entre enteros, siempre y cuando el resultado permanezca en rango. No es el caso de la división que da como resultado un número racional que puede no tener una representación perfecta. 

\begin{subsubsection}{Dificultadas y Decisiones tomadas}
\par
En la primera implementación del cálculo de las tres formas de calcular Pi, es decir usando los tipos de datos, \textbf{double} y \textbf{float}, se utilizó la función \textbf{pow} para el cálculo del término $(-1)^i$. Pero esta forma de calcularlo trajo inconvenientes en el desarrollo teórico, dado que al calcular la propagación de dicho término hay que conocer la derivada del mismo y este término no es derivable. Por eso, se decidió modificar la implementación. Como el término sólo toma los valores $-1$ y $1$ alternadamente, según la paridad de $i$, se decidio implementar esto con un \textbf{if}.

\par
En el apéndice B solamente se incluye el código final utilizando la clase Float que se realizó para proveer artimética finita.

%~ Cuando se desarrollo la formula de propagacion de error en la serie de Ramanujan nos encontramos con la dificultad de que los enteros en el 3 termino no eran representables perfectamente ya que sobrepasaban el rango de representacion utilizado. A efecto de solucionar este problema se intento simplificar elementos del numerador y el denominador de la serie 
%~ \begin{equation*}
%~ \frac{1}{\pi} = \frac{\sqrt{8}}{9801} \sum_{i=0}^{\infty} \frac{(4i)! \, (1103 + 26390 i)}{(i!)^4 \, 396^{4i}}
%~ \end{equation*}
%~ este intento fue futil, ya que si bien la situacion mejoro, el termino exponencial superaba el rango incluso de los tipos de mayor rango como long unsigned int. Esto nos llevo a abandonar nuestros intentos de implementar el algoritmo con enteros y a implementar el factorial con tipos de dato double favoreciendo asi el rango sobre el error. 
\end{subsubsection}

%~ \par
%~ Esto permitió simplificar los errores de representación y de ciertas operaciones entre los enteros, en la propagación de error en el tercer término de las fórmulas de Machin y Gregory, ya que todos los enteros hasta ese termino permanecen en rango. Sin embargo, para la serie de Ramanujan no fue posible simplificar la fórmula en la propagación de error ya que varios términos se salen de rango en el 3 termino de la serie. Si bien este hecho pareciera implicar que la serie de Ramanujan tiene un error mayor que las demas esta serie es la que tiende a Pi más rápidamente a una velocidad de 8 cifras decimales por término.
%~ Por lo tanto, $\err_{(2i+1)} = 0$
%~ 
%~ $$\err_{(2i+1)} = 0$$

\begin{subsubsection}{Errores en cada Término}
\paragraph{}
\textbf{Serie de Gregory}
$$\err_{g_i} = \err_{1} - \err_{(2i+1)} + \err_{/} $$
\par
Se considera que el $1$ no tiene errores de representación. Para $2.i + 1$, a pesar de ser un número entero debe considerarse su error porque la división es una operación que debe realizarse entre números de punto flotante. Se obtiene entonces lo siguiente: \\
	$$ \err_{g_i} = 0 - (\frac{(\err_2 + \err_i + \err_{*})}{2i+1} + \frac{\err_1}{2i+1} + \err_{+}) + \err_{/} = -\frac{(\err_2 + \err_i + \err_{*})}{2i+1} - \err_{+} + \err_{/} $$ 
\par
$2.i + 1$ es un número positivo y mayor o igual a $1$, por ser $i$ positivo, por lo tanto puede acotarse la división \\
$$ \err_{g_i} \leq -(\err_2 + \err_i + \err_{*}) - \err_{+} + \err_{/} $$

\textbf{Fórmula de Machin}
$$ \err_{{m(x)}_i} = \err_{x^{2i+1}} - \err_{2.i+1} + \err_{/} = $$
	$$ ((2.i+1).\err_x + ln(x).(2.i+1).\err_{2.i+1} + \err_{\wedge}) - \err_{2.i+1} + \err_{/} \mbox{  si } x > 0$$	
\par
$ln(x)$ puede acotarse por $x$, 
%~ Y esta es mi super referencia, aunque es obviamente cierto http://www.wolframalpha.com/input/?i=ln%28x%29%3Cx
  y sabiendo que en los casos utilizados $x$ es mayor a $0$, se obtiene lo siguiente:\\
$$ \err_{{m(x)}_i} \leq  ((2.i+1).\err_x + x.(2.i+1).(\frac{(\err_2 + \err_i + \err_{*})}{2i+1} + \err_{+}) + \err_{\wedge}) -\frac{(\err_2 + \err_i + \err_{*})}{2i+1} - \err_{+} + \err_{/} $$	
\par
Acotando igual que en el caso anterior\\
$$ \err_{{m(x)}_i} \leq  (2.i+1).(\err_x + x.(\err_2 + \err_i + \err_{*})) + \err_{+} + \err_{\wedge} - (\err_2 + \err_i + \err_{*}) - \err_{+} + \err_{/} $$	

\textbf{Serie de Ramanujan}
$$\err_{{r}_i} = \err_{(4i)! \, (1103 + 26390 i)} - \err_{(i!)^4 \, 396^{4i}} + \err_{/} = $$
$$\frac{\err_{(4i)!}}{(4i)! \, (1103 + 26390 i)} + \frac{\err_{(1103 + 26390 i)}}{(4i)! \, (1103 + 26390 i)} + \err_{*} - 
(\frac{\err_{(i!)^4}}{(i!)^4 \, 396^{4i}} + \frac{\err_{396^{4i}}}{(i!)^4 \, 396^{4i}} + \err_{*}) + \err_{/} $$
\par
Todos los denominadores son valores positivos mayores o iguales a 1, por lo tanto pueden acotarse las divisiones \\
$$\err_{{r}_i} \leq \err_{(4i)!} + \err_{(1103 + 26390 i)} + \err_{*} - (\err_{(i!)^4} + \err_{396^{4i}} + \err_{*}) + \err_{/} $$
$$ \err_{(4i)!} \leq (4i-2) (max\{\err_{*}\} + max\{\err_{j}\}) \leq (4i) (max\{\err_{*}\} + max\{\err_{j}\})$$
$$  \err_{(1103 + 26390 i)} = \frac{1103.\err_{1103}}{(1103 + 26390 i)} + \frac{26390.i.\err_{26390.i}}{(1103 + 26390 i)} \leq 1103.\err_{1103} + 26390.i.\err_{26390.i} \leq $$ $$1103.\err_{1103} + 26390.i.(\err_{26390} + \err_{i} + \err_{*})$$
$$ \err_{(i!)^4} = 4.\err_{i!} + ln(i!)4.\err_{4} + \err_{\wedge}$$
\par
Se analiza por separado $ln(i!)$ usando propiedades del logaritmo\\
$$ ln(i!) = ln(\prod_{j=1}^{i} j) = \sum_{j=1}^{i} ln(j)$$
Por ser el logaritmo una función creciente, 
$$ ln(i!) \leq \sum_{j=1}^{i} ln(i) \leq i.ln(i)$$
$$ \err_{(i!)^4} \leq 4.(i-2) (max\{\err_{*}\} + max\{\err_{j}\}) + 4i.ln(i).\err_{4} + \err_{\wedge} \leq (4i) (max\{\err_{*}\} + max\{\err_{j}\} + ln(i).\err_{4}) + \err_{\wedge}$$
$$ \err_{396^{4i}} = 4i.\err_{396} + ln(396)4i.\err_{4i} + \err_{\wedge} \leq 4i(\err_{396} + 396\err_{4i}) + \err_{\wedge} = (4i)(\err_{396} + 396(\err_{4} + \err_{i} + \err_{*})) + \err_{\wedge}$$

Juntando todo
$$\err_{{r}_i} \leq (4i)(max\{\err_{*}\} + max\{\err_{j}\} - max\{\err_{*}\} - max\{\err_{j}\} - ln(i).\err_{4} - \err_{396} - 396(\err_{4} + \err_{i} + \err_{*})) + $$ $$1103.\err_{1103} + 26390.i.(\err_{26390} + \err_{i} + \err_{*}) - \err_{\wedge} - \err_{\wedge} + \err_{*} + \err_{*} + \err_{/}$$

\begin{center} \textbf{En resumen}
\vskip 10pt
Teniendo en cuenta que los valores obtenidos pueden acotarse por la suma de los módulos, se tienen las siguientes cotas para los errores:
\vskip 10pt
%~ \fbox{$\err_{g_i} \leq |\err_2| + |\err_i| + |\err_{*}| + |\err_{+}| + |\err_{/}|$}
$$\err_{g_i} \leq |\err_2| + |\err_i| + |\err_{*}| + |\err_{+}| + |\err_{/}|$$
%~ \vskip 10pt
%~ \fbox{$\err_{{m(x)}_i} \leq 2.i+1.(|\err_x| + |x|.(|\err_2| + |\err_i| + |\err_{*}|)) + |\err_{+}| + |\err_{\wedge}| + |\err_2| + |\err_i| + |\err_{*}| + |\err_{+}| + |\err_{/}|$}
$$\err_{{m(x)}_i} \leq 2.i+1.(|\err_x| + |x|.(|\err_2| + |\err_i| + |\err_{*}|)) + |\err_{+}| + |\err_{\wedge}| + |\err_2| + |\err_i| + |\err_{*}| + |\err_{+}| + |\err_{/}|$$
%~ \vskip 10pt
%~ \fbox{$\err_{r_i} \leq 4i(max\{|\err_{*}|\} + max\{|\err_{j}|\} + max\{|\err_{*}|\} + max\{|\err_{j}|\} + |ln(i)|.|\err_{4}| + |\err_{396}| + 396(|\err_{4}| + |\err_{i}| + |\err_{*}|)) + 1103.|\err_{1103}| + 26390.i.(|\err_{26390}| + |\err_{i}| + |\err_{*}|) + |\err_{\wedge}| + |\err_{\wedge}| + |\err_{*}| + |\err_{*}| + |\err_{/}|$}
$$\err_{r_i} \leq 4i(max\{|\err_{*}|\} + max\{|\err_{j}|\} + max\{|\err_{*}|\} + max\{|\err_{j}|\} + |ln(i)|.|\err_{4}| + |\err_{396}| + 396(|\err_{4}| + |\err_{i}| + |\err_{*}|)) + $$ $$1103.|\err_{1103}| + 26390.i.(|\err_{26390}| + |\err_{i}| + |\err_{*}|) + |\err_{\wedge}| + |\err_{\wedge}| + |\err_{*}| + |\err_{*}| + |\err_{/}|$$
\end{center}

\par
Estos errores reflejan el error que se comete al calcular el término $i$ de cada serie. Esto puede utilizarse para el desarrollo de la propagación del error, teniendo en cuenta no sólo el error de cada término por separado sino también el error que se comete al sumar y/o restar los distintos términos entre sí.
\end{subsubsection}

\begin{subsubsection}{Errores en el tercer término}
En general, para una función $f$, 
$$F(2) = \sum_{i=0}^2 f_i = f_0 + f_1 + f_2 = (f_0 + f_1) + f_2 $$
$$\err_{F(2)} = \err_{(f_0 + f_1) + f_2} = \frac{(f_0 + f_1).\err_{(f_0 + f_1)}}{(f_0 + f_1) + f_2} + \frac{f_2.\err_{f_2}}{(f_0 + f_1) + f_2} + \err_{+}$$
$$ = \frac{(f_0 + f_1).(\frac{f_0.\err_{f_0}}{f_0 + f_1} + \frac{f_1.\err_{f_1}}{f_0 + f_1} + \err_{+})}{(f_0 + f_1) + f_2} + \frac{f_2.\err_{f_2}}{(f_0 + f_1) + f_2} + \err_{+}$$
\begin{center} $\err_{f_0}$ y $\err_{f_1}$ se consideran dados \end{center}

\newpage
\begin{center} \textbf{Para cada función} \end{center}
%~ \paragraph{} 
$$g_0 = 1 \hspace*{10pt} g_1 = \frac{-1}{3} \hspace*{10pt} g_2 = \frac{1}{5}$$
$$m_0 = x \hspace*{10pt} m_1 = \frac{-x^3}{3} \hspace*{10pt} m_2 = \frac{x^5}{5}$$
$$r_0 = 1103 \hspace*{10pt} r_1 = \frac{27493}{1024635744} \hspace*{10pt} r_2 = \frac{209545}{933225251451052032}$$

\par
En la fórmula de Machin a diferencia de las otras, se tienen dos series, una para calcular cada arcotangente y se realiza al final una multiplicación de cada arcotangente por un valor y una resta. Se consideró que el peso del cálculo está en la obtención del valor del arcotangente y por lo tanto el error de esta fórmula se expresa en función del error al calcular el arcotangente. Se deja expresado en función de $x$ que será el valor del cual se quiere obtener el arcotangente.

$$g_0 + g1 = \frac{2}{3} \hspace*{10pt} g_0 + g_1 + g_2 = \frac{5}{8}$$
$$m_0 + m_1 = x - \frac{x^3}{3} \hspace*{10pt} m_0 + m_1 + m_2 = x - \frac{x^3}{3} + \frac{x^5}{5}$$
$$r_0 + r_1 = \frac{1130173253125}{1024635744} \hspace*{10pt} r_0 + r_1 + r_2 = \frac{1029347477390786609545}{933225251451052032}$$

\par
Utilizando estos valores numéricos y las cotas obtenidas para el error en cada término puede obtenerse una cota para el error en el tercer término de cada serie.
%~ http://www.wolframalpha.com/input/?i=%28%284*0%29!+%281103+%2B+26390*0%29%29%2F%28%280!%29^4*396^%284*0%29%29
%~ http://www.wolframalpha.com/input/?i=%28%284*1%29!+%281103+%2B+26390*1%29%29%2F%28%281!%29^4*396^%284*1%29%29
%~ http://www.wolframalpha.com/input/?i=%28%284*2%29!+%281103+%2B+26390*2%29%29%2F%28%282!%29^4*396^%284*2%29%29
\end{subsubsection}
\end{subsection}


\begin{subsection}{Análisis Empiríco}
En esta sección se analiza el comportamiento de los algoritmos previamente realizados (ver apéndice B) para el cálculo de las tres series y el error cometido al realizar las operaciones. 
Es importante destacar que si bien los algoritmos mantienen su estructura previa, los gráficos y los cálculos presentados en esta sección fueron realizados
mediante una clase llamada Float implementada con el propósito de poder analizar el comportamiento de las series y de sus errores cuando se varia la precisión 
aritmética. 
\begin{subsubsection}{Operaciones en aritmetica finita} 
Para realizar las operaciones de las series todos los valores en cuestión se toman como valores de la clase Float, de esta forma todos los cálculos se realizan con la misma precisión. 
\begin{figure}[H] \centering
	\subfloat{\includegraphics[scale=.48]{./otros/ep.png}}	
\end{figure}
%lo que sigue en teoria lo vamos a cambiar por redondeo
%~ Para lograr un truncamiento correcto en las operaciones se convierten a Float los dos operandos se calcula el resultado 
%~ en 80 bits y luego se vuelve a truncar el resultado con presicion t.
\end{subsubsection}
%~ \paragraph{}
\begin{subsubsection}{Implementación de la clase Float, para trabajar con una aritmética de t dígitos de precisión}	

Como puede verse en el código provisto en el apéndice, la clase Float tiene los siguientes elementos:
\begin{itemize}
	\item \textbf{\_isNeg}: un bool que indica si el número en cuestión es negativo.
	\item \textbf{\_mantissa}: un string que contiene unos y ceros representando la mantisa del número en cuestión, según la precisión t indicada, es decir tiene t elementos.
	\item \textbf{\_exponent}: un int que indica el exponente al cual debe elevarse 2 para la representación.
	\item \textbf{\_precision}: un int que indica la precisión utilizada para la representación, es el t.
	\item \textbf{\_value}: un long double que contiene el valor representado utilizando los demás elementos.	
\end{itemize}

\par
Para crear un número de tipo Float, se recibe por un lado la precisión deseada y por otro un valor en long double. Luego se procede a convertir ese valor a la representación elegida, es decir usando mantisa y exponente. Para realizar la conversión, la clase tiene funciones auxiliares que pasan de long double a binario y de binario a long double.
\par
Para pasar de long double a binario, se toma inicialmente el valor como la mantisa, y se procede a normalizar. El exponente se inicializa en 0, y puede ir aumentando o disminuyendo según se vaya normalizando la mantisa. La mantisa termina siendo un valor m tal que 0.5 $\leq$ m $<$ 1. Luego de haber obtenido este valor, se procede a convertir a binario, para formar el string que representa la mantisa, esta conversión se detiene cuando \_mantissa llega a tener t elementos. Si ya se terminó la conversión y no se llegaron a completar los t dígitos, se llena con ceros. Y si ya se llego a los t dígitos, se trunca la representación.
\par
Para pasar de binario a long double, simplemente se realiza una conversión del valor de la mantisa a binario y se eleva 2 al exponente, el signo se obtiene del bool \_isNeg.
\par
La clase provee funciones para poder observar cada uno de los elementos internos, de estas la función más utilizada es aquella que devuelve el valor, ya que al tener que imprimir un valor la forma de obtenerlo es mediante esta función.
\par
Las operaciones entre Floats, se realizan utilizando los valores guardados en value y luego convirtiendo el resultado obtenido a binario. Es decir se devuelve un nuevo Float que se crea usando precisión t y valor de entrada el resultado en long double de la operación en cuestión.
\end{subsubsection}

%~ \begin{center} \textbf{Interpretacion de los graficos} \end{center}
\end{subsection}
\end{section}
